response = graph.query(recommendation_query_db_history, params)
         try:
             return (
-                'Recommended movies are: '
+                "Recommended movies are: "
                 f'{f"###Movie {nl}".join([el["movie"] for el in response])}'
             )
         except Exception:

         response = graph.query(recommendation_query_genre, params)
         try:
             return (
-                'Recommended movies are: '
+                "Recommended movies are: "
                 f'{f"###Movie {nl}".join([el["movie"] for el in response])}'
             )
         except Exception:

     response = graph.query(query, params)
     try:
         return (
-            'Recommended movies are: '
+            "Recommended movies are: "
             f'{f"###Movie {nl}".join([el["movie"] for el in response])}'
         )
     except Exception:

         for err_code in actual_failures - expected_failures:
             sys.stdout.write(
                 f'{prefix}{res["file"]}:{res["file_line"]}:'
-                f'{err_code}:{func_name}:{error_messages[err_code]}\n'
+                f"{err_code}:{func_name}:{error_messages[err_code]}\n"
             )
             exit_status += 1
         for err_code in ignore_errors.get(func_name, set()) - actual_failures:

             return
 
         log.error(
-            f'{task_str} dies with exception: {greenlet.exception}.\n'
-            f'Exception Name: {greenlet.exc_info[0]}\n'
-            f'Exception Info: {greenlet.exc_info[1]}\n'
+            f"{task_str} dies with exception: {greenlet.exception}.\n"
+            f"Exception Name: {greenlet.exc_info[0]}\n"
+            f"Exception Info: {greenlet.exc_info[1]}\n"
             f'Traceback:\n {"".join(traceback.format_tb(greenlet.exc_info[2]))}',
         )
         # also write an error for the task result if it's not the main greenlet

         if identifiers is not None:
             return api_response(
                 result=wrap_in_fail_result(
-                    f'Failed to add {asset.asset_type!s} {asset.name} '
+                    f"Failed to add {asset.asset_type!s} {asset.name} "
                     f'since it already exists. Existing ids: {",".join(identifiers)}'
                 ),
                 status_code=HTTPStatus.CONFLICT,

     ) -> dict[str, Any]:
         """Return the current price of the assets in the target asset currency."""
         log.debug(
-            f'Querying the current {target_asset.identifier} price of these assets: '
+            f"Querying the current {target_asset.identifier} price of these assets: "
             f'{", ".join([asset.identifier for asset in assets])}',
         )
         # Type is list instead of tuple here because you can't serialize a tuple

         asset currency.
         """
         log.debug(
-            f'Querying the historical {target_asset.identifier} price of these assets: '
+            f"Querying the historical {target_asset.identifier} price of these assets: "
             f'{", ".join(f"{asset.identifier} at {ts}" for asset, ts in assets_timestamp)}',
             assets_timestamp=assets_timestamp,
         )

 
         if self.limit_to is not None and chain_id not in self.limit_to:
             raise ValidationError(
-                f'Given chain_id {value} is not one of '
+                f"Given chain_id {value} is not one of "
                 f'{",".join([str(x) for x in self.limit_to])} as needed by the endpoint',
             )
 

 
         if self.limit_to is not None and chain not in self.limit_to:
             raise ValidationError(
-                f'Given chain {value} is not one of '
+                f"Given chain {value} is not one of "
                 f'{",".join([str(x) for x in self.limit_to])} as needed by the endpoint',
             )
 

 
         if self.limit_to is not None and location not in self.limit_to:
             raise ValidationError(
-                f'Given location {value} is not one of '
+                f"Given location {value} is not one of "
                 f'{",".join([str(x) for x in self.limit_to])} as needed by the endpoint',
             )
 

                 and not any(value.filename.endswith(x) for x in self.allowed_extensions)
             ):  # noqa: E501
                 raise ValidationError(
-                    f'Given file {value.filename} does not end in any of '
+                    f"Given file {value.filename} does not end in any of "
                     f'{",".join(self.allowed_extensions)}',
                 )
 

             path.suffix == x for x in self.allowed_extensions
         ):  # noqa: E501
             raise ValidationError(
-                f'Given file {path} does not end in any of '
+                f"Given file {path} does not end in any of "
                 f'{",".join(self.allowed_extensions)}',
             )
 

             data["order_by_attributes"]
         ).issubset(valid_ordering_attr):
             error_msg = (
-                f'order_by_attributes for trades can not be '
+                f"order_by_attributes for trades can not be "
                 f'{",".join(set(data["order_by_attributes"]) - valid_ordering_attr)}'
             )
             raise ValidationError(

             data["order_by_attributes"]
         ).issubset(valid_ordering_attr):
             error_msg = (
-                f'order_by_attributes for history event data can not be '
+                f"order_by_attributes for history event data can not be "
                 f'{",".join(set(data["order_by_attributes"]) - valid_ordering_attr)}'
             )
             raise ValidationError(

             data["order_by_attributes"]
         ).issubset(valid_ordering_attr):
             error_msg = (
-                f'order_by_attributes for asset movements can not be '
+                f"order_by_attributes for asset movements can not be "
                 f'{",".join(set(data["order_by_attributes"]) - valid_ordering_attr)}'
             )
             raise ValidationError(

         raise ValidationError(
             f'Invalid current price oracles in: {", ".join(oracle_names)}. '
             f'Supported oracles are: {", ".join(supported_oracle_names)}. '
-            f'Check there are no repeated ones.',
+            f"Check there are no repeated ones.",
         )
 
 

         raise ValidationError(
             f'Invalid historical price oracles in: {", ".join(oracle_names)}. '
             f'Supported oracles are: {", ".join(supported_oracle_names)}. '
-            f'Check there are no repeated ones.',
+            f"Check there are no repeated ones.",
         )
 
 

             data["order_by_attributes"]
         ).issubset(valid_ordering_attr):
             error_msg = (
-                f'order_by_attributes for accounting report data can not be '
+                f"order_by_attributes for accounting report data can not be "
                 f'{",".join(set(data["order_by_attributes"]) - valid_ordering_attr)}'
             )
             raise ValidationError(

             data["order_by_attributes"]
         ).issubset(valid_ordering_attr):
             error_msg = (
-                f'order_by_attributes for eth2 daily stats can not be '
+                f"order_by_attributes for eth2 daily stats can not be "
                 f'{",".join(set(data["order_by_attributes"]) - valid_ordering_attr)}'
             )
             raise ValidationError(

         ):  # noqa: E501
             raise ValidationError(
                 f'timestamp provided {data["timestamp"]} is not the same as the '
-                f'one for the entries provided.',
+                f"one for the entries provided.",
             )
 
 

         unknown_accounts = set(accounts).difference(self.accounts.get(blockchain))
         if len(unknown_accounts) != 0:
             raise InputError(
-                f'Tried to remove unknown {blockchain.value} '
+                f"Tried to remove unknown {blockchain.value} "
                 f'accounts {",".join(unknown_accounts)}',
             )
 

     duplicate_names = set(log_topic_names).intersection(log_data_names)
     if duplicate_names:
         raise DeserializationError(
-            f'The following argument names are duplicated '
+            f"The following argument names are duplicated "
             f"between event inputs: '{', '.join(duplicate_names)}'",
         )
 

         with self.db.user_write() as write_cursor:
             # Remove NFTs that the user no longer owns from the DB cache
             write_cursor.execute(
-                f'DELETE FROM nfts WHERE owner_address IN '
+                f"DELETE FROM nfts WHERE owner_address IN "
                 f'({",".join("?" * len(addresses))}) AND identifier NOT IN '
                 f'({",".join("?" * len(fresh_nfts_identifiers))})',
                 tuple(addresses) + tuple(fresh_nfts_identifiers),

             raise RemoteError(f"Curve pool data {api_pool_data} are missing key {e}") from e
         except DeserializationError as e:
             log.error(
-                f'Could not deserialize evm address while decoding curve pool '
+                f"Could not deserialize evm address while decoding curve pool "
                 f'{api_pool_data["address"]} information from curve api: {e}',
             )
 

             return result
 
         raise RemoteError(
-            f'{manager.chain} request failed after trying the following nodes: '
+            f"{manager.chain} request failed after trying the following nodes: "
             f'{", ".join(requested_nodes)}',
         )
 

         """
         # Assure all are there
         accounts_number = write_cursor.execute(
-            f'SELECT COUNT(*) from blockchain_accounts WHERE blockchain = ? '
+            f"SELECT COUNT(*) from blockchain_accounts WHERE blockchain = ? "
             f'AND account IN ({",".join("?" * len(accounts))})',
             (blockchain.value, *accounts),
         ).fetchone()[0]

         ]
         for hashes_chunk in get_chunks(hashes_to_remove, n=1000):  # limit num of hashes in a query
             write_cursor.execute(  # delete transactions themselves
-                f'DELETE FROM zksynclite_transactions WHERE tx_hash IN '
+                f"DELETE FROM zksynclite_transactions WHERE tx_hash IN "
                 f'({",".join("?" * len(hashes_chunk))})',
                 hashes_chunk,
             )
             write_cursor.execute(
-                f'DELETE FROM history_events WHERE identifier IN (SELECT H.identifier '
-                f'FROM history_events H INNER JOIN evm_events_info E '
-                f'ON H.identifier=E.identifier AND E.tx_hash IN '
+                f"DELETE FROM history_events WHERE identifier IN (SELECT H.identifier "
+                f"FROM history_events H INNER JOIN evm_events_info E "
+                f"ON H.identifier=E.identifier AND E.tx_hash IN "
                 f'({", ".join(["?"] * len(hashes_chunk))}) AND H.location=?)',
                 hashes_chunk + [Location.ZKSYNC_LITE.serialize_for_db()],
             )

 
         if len(unknown_tags) != 0:
             raise TagConstraintError(
-                f'When {action} {data_type}, unknown tags '
+                f"When {action} {data_type}, unknown tags "
                 f'{", ".join(unknown_tags)} were found',
             )
 

         result = {}
         with self.conn.read_ctx() as cursor:
             cursor.execute(
-                f'SELECT identifier, name, collection_name, image_url FROM nfts WHERE '
+                f"SELECT identifier, name, collection_name, image_url FROM nfts WHERE "
                 f'identifier IN ({",".join("?" * len(identifiers))})',
                 identifiers,
             )

         """
         questionmarks = "?" * len(addresses)
         cursor.execute(
-            f'SELECT S.validator_index FROM eth_staking_events_info S LEFT JOIN '
-            f'history_events H on S.identifier=H.identifier WHERE H.location_label IN '
+            f"SELECT S.validator_index FROM eth_staking_events_info S LEFT JOIN "
+            f"history_events H on S.identifier=H.identifier WHERE H.location_label IN "
             f'({",".join(questionmarks)})',
             addresses,
         )

         with self.db.user_write() as cursor:
             # Delete from the validators table. This should also delete from daily_staking_details
             cursor.execute(
-                f'DELETE FROM eth2_validators WHERE validator_index IN '
+                f"DELETE FROM eth2_validators WHERE validator_index IN "
                 f'({",".join(question_marks)})',
                 validator_indices,
             )

             # Delete from the events table, all staking events except for deposits.
             # We keep deposits since they are associated with the address and are EVM transactions
             cursor.execute(
-                f'DELETE FROM history_events WHERE identifier in (SELECT S.identifier '
-                f'FROM eth_staking_events_info S WHERE S.validator_index IN '
+                f"DELETE FROM history_events WHERE identifier in (SELECT S.identifier "
+                f"FROM eth_staking_events_info S WHERE S.validator_index IN "
                 f'({",".join(question_marks)})) AND entry_type != ?',
                 (*validator_indices, HistoryBaseEntryType.ETH_DEPOSIT_EVENT.serialize_for_db()),
             )

 
             # also query the linked rules information
             cursor.execute(
-                'SELECT accounting_rule, property_name, setting_name FROM '
+                "SELECT accounting_rule, property_name, setting_name FROM "
                 f'linked_rules_properties WHERE accounting_rule IN ({",".join("?" * len(id_to_data))})',  # noqa: E501
                 list(id_to_data.keys()),
             )

             if single_contract_data["abi"] not in remote_id_to_local_id:
                 self.msg_aggregator.add_error(
                     f'ABI with id {single_contract_data["abi"]} was missing in a contracts '
-                    f'update. Please report it to the rotki team.',
+                    f"update. Please report it to the rotki team.",
                 )
                 continue
             new_contracts_data.append((

                 self.msg_aggregator.add_error(
                     f'Could not deserialize address {raw_entry["address"]} or blockchain '
                     f'{raw_entry["blockchain"]} that was seen in a global addressbook update. '
-                    f'Please report it to the rotki team. {e!s}',
+                    f"Please report it to the rotki team. {e!s}",
                 )
                 continue
 

     rate = deserialize_price(binance_trade["price"])
     if binance_trade["symbol"] not in binance_symbols_to_pair:
         raise DeserializationError(
-            f'Error reading a {location!s} trade. Could not find '
+            f"Error reading a {location!s} trade. Could not find "
             f'{binance_trade["symbol"]} in binance_symbols_to_pair',
         )
 

             except DeserializationError:
                 log.error(
                     f'Found {self.name} asset with non-string type {type(entry["asset"])}. '
-                    f'Ignoring its balance query.',
+                    f"Ignoring its balance query.",
                 )
                 continue
 

                     continue
                 except DeserializationError:
                     log.error(
-                        f'Found {self.name} asset with non-string type '
+                        f"Found {self.name} asset with non-string type "
                         f'{type(entry["asset"])}. Ignoring its futures balance query.',
                     )
                     continue

                     continue
                 except DeserializationError:
                     log.error(
-                        f'Found {self.name} asset with non-string type '
+                        f"Found {self.name} asset with non-string type "
                         f'{type(entry["asset"])}. Ignoring its margined futures balance query.',
                     )
                     continue

 
             if raw_result[timestamp_index] > options["end"]:
                 log.debug(
-                    f'Unexpected result requesting {self.name} {case}. '
-                    f'Result timestamp {raw_result[timestamp_index]} is greater than '
+                    f"Unexpected result requesting {self.name} {case}. "
+                    f"Result timestamp {raw_result[timestamp_index]} is greater than "
                     f'end filter {options["end"]}. Stop requesting.',
                     raw_result=raw_result,
                 )

         payload_string = urlencode(call_options)
         content_type = "" if payload_string == "" else "application/x-www-form-urlencoded"
         message = (
-            'BITSTAMP '
-            f'{self.api_key}'
-            f'{method.upper()}'
+            "BITSTAMP "
+            f"{self.api_key}"
+            f"{method.upper()}"
             f'{request_url.replace("https://", "")}'
-            f'{query_params}'
-            f'{content_type}'
-            f'{nonce}'
-            f'{timestamp}'
-            'v2'
-            f'{payload_string}'
+            f"{query_params}"
+            f"{content_type}"
+            f"{nonce}"
+            f"{timestamp}"
+            "v2"
+            f"{payload_string}"
         )
         signature = hmac.new(
             self.secret,

 
             if not isinstance(account_data["id"], str):
                 log.error(
-                    f'Found coinbase account entry with a non string id: '
+                    f"Found coinbase account entry with a non string id: "
                     f'{account_data["id"]}. Skipping it. ',
                 )
                 continue

                     if asset != asset_from_coinbase(fee_asset, time=timestamp):
                         # If not we set ZERO fee and ignore
                         log.error(
-                            f'In a coinbase withdrawal of {asset.identifier} the fee'
+                            f"In a coinbase withdrawal of {asset.identifier} the fee"
                             f'is denoted in {raw_fee["currency"]}',
                         )
                     else:

 
             if count != response["count"]:
                 log.error(
-                    f'Kraken unexpected response while querying endpoint for period. '
+                    f"Kraken unexpected response while querying endpoint for period. "
                     f'Original count was {count} and response returned {response["count"]}',
                 )
                 with_errors = True

                 if entry["id"] in data:
                     log.warning(
                         f'Found duplicate coingecko identifier {entry["id"]} when querying '
-                        f'the list of coingecko assets. Ignoring...',
+                        f"the list of coingecko assets. Ignoring...",
                     )
                     continue
 

         can_query = got_cached_data or not rate_limited
         log.debug(
             f'{"Will" if can_query else "Will not"} query '
-            f'Cryptocompare history for {from_asset.identifier} -> '
-            f'{to_asset.identifier} @ {timestamp}. Cached data: {got_cached_data}'
-            f' rate_limited in last {seconds} seconds: {rate_limited}',
+            f"Cryptocompare history for {from_asset.identifier} -> "
+            f"{to_asset.identifier} @ {timestamp}. Cached data: {got_cached_data}"
+            f" rate_limited in last {seconds} seconds: {rate_limited}",
         )
         return can_query
 

                 except DeserializationError as e:
                     log.error(
                         f"Failed to read transaction timestamp {entry['hash']} from {self.chain} "
-                        f'etherscan for {account} in the range {from_ts} to {to_ts}. {e!s}',
+                        f"etherscan for {account} in the range {from_ts} to {to_ts}. {e!s}",
                     )
                     continue
 

                 except DeserializationError as e:
                     log.error(
                         f"Failed to read transaction hash {entry['hash']} from {self.chain} "
-                        f'etherscan for {account} in the range {from_ts} to {to_ts}. {e!s}',
+                        f"etherscan for {account} in the range {from_ts} to {to_ts}. {e!s}",
                     )
                     continue
 

         """Return the gnosis pay data matching the given DB data"""
         with self.database.conn.read_ctx() as cursor:
             cursor.execute(
-                f'SELECT tx_hash, timestamp, merchant_name, merchant_city, country, mcc, '
-                f'transaction_symbol, transaction_amount, billing_symbol, billing_amount, '
-                f'reversal_symbol, reversal_amount, reversal_tx_hash '
+                f"SELECT tx_hash, timestamp, merchant_name, merchant_city, country, mcc, "
+                f"transaction_symbol, transaction_amount, billing_symbol, billing_amount, "
+                f"reversal_symbol, reversal_amount, reversal_tx_hash "
                 f'{", identifier " if with_identifier else ""}'
-                f'FROM gnosispay_data WHERE {wherestatement}',
+                f"FROM gnosispay_data WHERE {wherestatement}",
                 bindings,
             )
             if (result := cursor.fetchone()) is None:

                 else:  # should not happen. That means collections endpoint doesnt return anything
                     raise DeserializationError(
                         f'Could not find collection {entry["collection"]} in opensea collections '
-                        f'endpoint',
+                        f"endpoint",
                     )
 
             last_price_in_usd = last_price_in_eth * eth_usd_price

 
     if int(data["version"]) not in ASSETS_FILE_IMPORT_ACCEPTED_GLOBALDB_VERSIONS:
         raise InputError(
-            f'Provided file is for a different version of rotki. GlobalDB File version: '
+            f"Provided file is for a different version of rotki. GlobalDB File version: "
             f'{data["version"]} Accepted GlobalDB version by rotki: {ASSETS_FILE_IMPORT_ACCEPTED_GLOBALDB_VERSIONS}',  # noqa: E501
         )
     if data["assets"] is None:

             # results before hand, in the range from 10 to 100 and this guarantees that the size of
             # the query is small.
             underlying_tokens_query = (
-                f'SELECT parent_token_entry, address, token_kind, weight FROM '
-                f'underlying_tokens_list LEFT JOIN evm_tokens ON '
-                f'underlying_tokens_list.identifier=evm_tokens.identifier '
+                f"SELECT parent_token_entry, address, token_kind, weight FROM "
+                f"underlying_tokens_list LEFT JOIN evm_tokens ON "
+                f"underlying_tokens_list.identifier=evm_tokens.identifier "
                 f'WHERE parent_token_entry IN ({",".join(["?"] * len(assets_info))})'
             )
             # populate all underlying tokens

                 )
         except sqlite3.IntegrityError as e:
             log.error(
-                f'One of the following asset ids caused a DB IntegrityError ({e!s}): '
+                f"One of the following asset ids caused a DB IntegrityError ({e!s}): "
                 f'{",".join([x.identifier for x in assets])}',
             )  # should not ever happen but need to handle with informative log if it does
 

         "KSM",
     )
     cursor.execute(
-        f'SELECT from_asset, to_asset, source_type, timestamp, price FROM '
+        f"SELECT from_asset, to_asset, source_type, timestamp, price FROM "
         f'price_history WHERE (source_type=="A" OR from_asset IN ({",".join(["?"] * len(assets))}))',  # noqa: E501
         assets,
     )

             return
 
         msg = (
-            f'{first_line}.\n'
-            f'Exception Name: {greenlet.exc_info[0]}\nException Info: {greenlet.exc_info[1]}'
+            f"{first_line}.\n"
+            f"Exception Name: {greenlet.exc_info[0]}\nException Info: {greenlet.exc_info[1]}"
             f'\nTraceback:\n {"".join(traceback.format_tb(greenlet.exc_info[2]))}'
         )
         log.error(msg)

 
             if len(exchange_names) != 0:
                 self.msg_aggregator.add_error(
-                    f'Failed to query some events from {location.name} exchanges '
+                    f"Failed to query some events from {location.name} exchanges "
                     f'{",".join(exchange_names)}',
                 )
 

             if weight_sum > ONE:
                 raise ValidationError(
                     f'The sum of underlying token weights for {data["address"]} '
-                    f'is {weight_sum * 100} and exceeds 100%',
+                    f"is {weight_sum * 100} and exceeds 100%",
                 )
             if weight_sum < ONE:
                 raise ValidationError(
                     f'The sum of underlying token weights for {data["address"]} '
-                    f'is {weight_sum * 100} and does not add up to 100%',
+                    f"is {weight_sum * 100} and does not add up to 100%",
                 )
 
     @post_load

         current_greenlets = len(self.greenlet_manager.greenlets) + len(self.api_task_greenlets)
         not_proceed = current_greenlets >= self.max_tasks_num
         log.debug(
-            f'At task scheduling. Current greenlets: {current_greenlets} '
-            f'Max greenlets: {self.max_tasks_num}. '
+            f"At task scheduling. Current greenlets: {current_greenlets} "
+            f"Max greenlets: {self.max_tasks_num}. "
             f'{"Will not schedule" if not_proceed else "Will schedule"}.',
         )
         if not_proceed:

             test_warnings.warn(
                 UserWarning(
                     f'Found unknown asset {e.identifier} with symbol {coin["id"]} in Coinbase. '
-                    f'Support for it has to be added',
+                    f"Support for it has to be added",
                 )
             )

             identifiers[0]
             for cursor in (old_db_cursor, packaged_db_cursor)
             for identifiers in cursor.execute(
-                f'SELECT identifier FROM evm_tokens WHERE '
+                f"SELECT identifier FROM evm_tokens WHERE "
                 f'protocol IN ({",".join(["?"] * len(IGNORED_PROTOCOLS))}) OR '
-                f'address in (SELECT value FROM general_cache)',
+                f"address in (SELECT value FROM general_cache)",
                 list(IGNORED_PROTOCOLS),
             ).fetchall()
         }

     ):
         result = cursor.execute(  # additions are not present already
             f"SELECT {'COUNT(*)' if after_upgrade is False else 'local_id'} "
-            'FROM location_asset_mappings WHERE location IS ? AND exchange_symbol IS ?',
+            "FROM location_asset_mappings WHERE location IS ? AND exchange_symbol IS ?",
             (
                 None
                 if addition["location"] is None

         names = [str(x) for idx, x in enumerate(connect_at_start) if not connected[idx]]
         log.warning(
             f'Did not connect to nodes: {",".join(names)} due to '
-            f'timeout of {NODE_CONNECTION_TIMEOUT}. Connected to {connected}',
+            f"timeout of {NODE_CONNECTION_TIMEOUT}. Connected to {connected}",
         )
 
 

     not_connected_nodes = set(node_names) - connected_nodes
     if not_connected_nodes:
         log.info(
-            f'Substrate {chain} tests failed to connect to nodes: '
+            f"Substrate {chain} tests failed to connect to nodes: "
             f'{",".join([str(node) for node in not_connected_nodes])} ',
         )
 

     except gevent.Timeout:
         not_connected_nodes = all_nodes - connected
         log.info(
-            f'{substrate_manager.chain} manager failed to connect to '
+            f"{substrate_manager.chain} manager failed to connect to "
             f'nodes: {",".join([str(node) for node in not_connected_nodes])} '
-            f'due to timeout of {NODE_CONNECTION_TIMEOUT}',
+            f"due to timeout of {NODE_CONNECTION_TIMEOUT}",
         )